/*

  Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.

  This program is free software; you can redistribute it and/or modify it
  under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it would be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

  Further, this software is distributed without any warranty that it is
  free of the rightful claim of any third person regarding infringement 
  or the like.  Any license provided herein, whether implied or 
  otherwise, applies only to this software file.  Patent licenses, if 
  any, provided herein do not apply to combinations of this program with 
  other software, or any other product whatsoever.  

  You should have received a copy of the GNU General Public License along
  with this program; if not, write the Free Software Foundation, Inc., 59
  Temple Place - Suite 330, Boston MA 02111-1307, USA.

  Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

*/


#include <stdio.h>
#include <stdlib.h>
#include <cmplrs/rcodes.h>

#include "defs.h"
#include "wintrinsic.h"
#include "wio.h"
#include "wutil.h"
#include "ir_a2b_util.h"                // for b2a and a2b utilities


// eraxxon (2005.01): Re-implement these routines to support
// conversion in both directions.

// The type for enumeration value -> string tables
struct EnumToStr_t : public ir_a2b::enum2str_tbl_entry_t {
  EnumToStr_t(INT val_ = 0, const char* str_ = 0) 
    : val(val_), str(str_) { }

  virtual ~EnumToStr_t() { }

  virtual INT getEnumVal()     const { return val; }
  virtual const char* getStr() const { return str; }

  INT         val;
  const char* str;
};



EnumToStr_t IntrinsicToNameTbl [] = {
  EnumToStr_t(INTRINSIC_NONE,		"NONE"),
  EnumToStr_t(INTRN_I4EXPEXPR,		"I4EXPEXPR"),
  EnumToStr_t(INTRN_I8EXPEXPR,		"I8EXPEXPR"),
  EnumToStr_t(INTRN_F4EXPEXPR,		"F4EXPEXPR"),
  EnumToStr_t(INTRN_F8EXPEXPR,		"F8EXPEXPR"),
  EnumToStr_t(INTRN_FQEXPEXPR,		"FQEXPEXPR"),
  EnumToStr_t(INTRN_C4EXPEXPR,		"C4EXPEXPR"),
  EnumToStr_t(INTRN_C8EXPEXPR,		"C8EXPEXPR"),
  EnumToStr_t(INTRN_CQEXPEXPR,		"CQEXPEXPR"),
  EnumToStr_t(INTRN_F4I4EXPEXPR,	"F4I4EXPEXPR"),
  EnumToStr_t(INTRN_F4I8EXPEXPR,	"F4I8EXPEXPR"),
  EnumToStr_t(INTRN_F8I4EXPEXPR,	"F8I4EXPEXPR"),
  EnumToStr_t(INTRN_F8I8EXPEXPR,	"F8I8EXPEXPR"),
  EnumToStr_t(INTRN_FQI4EXPEXPR,	"FQI4EXPEXPR"),
  EnumToStr_t(INTRN_FQI8EXPEXPR,	"FQI8EXPEXPR"),
  EnumToStr_t(INTRN_C4I4EXPEXPR,	"C4I4EXPEXPR"),
  EnumToStr_t(INTRN_C4I8EXPEXPR,	"C4I8EXPEXPR"),
  EnumToStr_t(INTRN_C8I4EXPEXPR,	"C8I4EXPEXPR"),
  EnumToStr_t(INTRN_C8I8EXPEXPR,	"C8I8EXPEXPR"),
  EnumToStr_t(INTRN_CQI4EXPEXPR,	"CQI4EXPEXPR"),
  EnumToStr_t(INTRN_CQI8EXPEXPR,	"CQI8EXPEXPR"),
  EnumToStr_t(INTRN_CEQEXPR,		"CEQEXPR"),
  EnumToStr_t(INTRN_CNEEXPR,		"CNEEXPR"),
  EnumToStr_t(INTRN_CGEEXPR,		"CGEEXPR"),
  EnumToStr_t(INTRN_CGTEXPR,		"CGTEXPR"),
  EnumToStr_t(INTRN_CLEEXPR,		"CLEEXPR"),
  EnumToStr_t(INTRN_CLTEXPR,		"CLTEXPR"),
  EnumToStr_t(INTRN_SUBSTRINGEXPR,	"SUBSTRINGEXPR"),
  EnumToStr_t(INTRN_CONCATEXPR,		"CONCATEXPR"),
  EnumToStr_t(INTRN_CASSIGNSTMT,	"CASSIGNSTMT"),
  EnumToStr_t(INTRN_I2ABSe,		"I2ABSe"),
  EnumToStr_t(INTRN_I4ABSe,		"I4ABSe"),
  EnumToStr_t(INTRN_I8ABSe,		"I8ABSe"),
  EnumToStr_t(INTRN_F4ABSe,		"F4ABSe"),
  EnumToStr_t(INTRN_F8ABSe,		"F8ABSe"),
  EnumToStr_t(INTRN_FQABSe,		"FQABSe"),
  EnumToStr_t(INTRN_F4C4ABS,		"F4C4ABS"),
  EnumToStr_t(INTRN_F4C4ABSe,		"F4C4ABSe"),
  EnumToStr_t(INTRN_F8C8ABS,		"F8C8ABS"),
  EnumToStr_t(INTRN_F8C8ABSe,		"F8C8ABSe"),
  EnumToStr_t(INTRN_FQCQABS,		"FQCQABS"),
  EnumToStr_t(INTRN_FQCQABSe,		"FQCQABSe"),
  EnumToStr_t(INTRN_I2MODe,		"I2MODe"),
  EnumToStr_t(INTRN_I4MODe,		"I4MODe"),
  EnumToStr_t(INTRN_I8MODe,		"I8MODe"),
  EnumToStr_t(INTRN_F4MOD,		"F4MOD"),
  EnumToStr_t(INTRN_F4MODe,		"F4MODe"),
  EnumToStr_t(INTRN_F8MOD,		"F8MOD"),
  EnumToStr_t(INTRN_F8MODe,		"F8MODe"),
  EnumToStr_t(INTRN_FQMOD,		"FQMOD"),
  EnumToStr_t(INTRN_FQMODe,		"FQMODe"),
  EnumToStr_t(INTRN_F4SQRTe,		"F4SQRTe"),
  EnumToStr_t(INTRN_F8SQRTe,		"F8SQRTe"),
  EnumToStr_t(INTRN_FQSQRTe,		"FQSQRTe"),
  EnumToStr_t(INTRN_C4SQRTe,		"C4SQRTe"),
  EnumToStr_t(INTRN_C8SQRTe,		"C8SQRTe"),
  EnumToStr_t(INTRN_CQSQRTe,		"CQSQRTe"),
  EnumToStr_t(INTRN_C4CONJG,		"C4CONJG"),
  EnumToStr_t(INTRN_C4CONJGe,		"C4CONJGe"),
  EnumToStr_t(INTRN_C8CONJG,		"C8CONJG"),
  EnumToStr_t(INTRN_C8CONJGe,		"C8CONJGe"),
  EnumToStr_t(INTRN_CQCONJG,		"CQCONJG"),
  EnumToStr_t(INTRN_CQCONJGe,		"CQCONJGe"),
  EnumToStr_t(INTRN_I1DIM,		"I1DIM"),
  EnumToStr_t(INTRN_I2DIM,		"I2DIM"),
  EnumToStr_t(INTRN_I2DIMe,		"I2DIMe"),
  EnumToStr_t(INTRN_I4DIM,		"I4DIM"),
  EnumToStr_t(INTRN_I4DIMe,		"I4DIMe"),
  EnumToStr_t(INTRN_I8DIM,		"I8DIM"),
  EnumToStr_t(INTRN_I8DIMe,		"I8DIMe"),
  EnumToStr_t(INTRN_F4DIM,		"F4DIM"),
  EnumToStr_t(INTRN_F4DIMe,		"F4DIMe"),
  EnumToStr_t(INTRN_F8DIM,		"F8DIM"),
  EnumToStr_t(INTRN_F8DIMe,		"F8DIMe"),
  EnumToStr_t(INTRN_FQDIM,		"FQDIM"),
  EnumToStr_t(INTRN_FQDIMe,		"FQDIMe"),
  EnumToStr_t(INTRN_F8F4PROD,		"F8F4PROD"),
  EnumToStr_t(INTRN_F8F4PRODe,		"F8F4PRODe"),
  EnumToStr_t(INTRN_FQF8PROD,		"FQF8PROD"),
  EnumToStr_t(INTRN_FQF8PRODe,		"FQF8PRODe"),
  EnumToStr_t(INTRN_I1SIGN,		"I1SIGN"),
  EnumToStr_t(INTRN_I2SIGN,		"I2SIGN"),
  EnumToStr_t(INTRN_I2SIGNe,		"I2SIGNe"),
  EnumToStr_t(INTRN_I4SIGN,		"I4SIGN"),
  EnumToStr_t(INTRN_I4SIGNe,		"I4SIGNe"),
  EnumToStr_t(INTRN_I8SIGN,		"I8SIGN"),
  EnumToStr_t(INTRN_I8SIGNe,		"I8SIGNe"),
  EnumToStr_t(INTRN_F4SIGN,		"F4SIGN"),
  EnumToStr_t(INTRN_F4SIGNe,		"F4SIGNe"),
  EnumToStr_t(INTRN_F8SIGN,		"F8SIGN"),
  EnumToStr_t(INTRN_F8SIGNe,		"F8SIGNe"),
  EnumToStr_t(INTRN_FQSIGN,		"FQSIGN"),
  EnumToStr_t(INTRN_FQSIGNe,		"FQSIGNe"),
  EnumToStr_t(INTRN_F4IMAGe,		"F4IMAGe"),
  EnumToStr_t(INTRN_F8IMAGe,		"F8IMAGe"),
  EnumToStr_t(INTRN_FQIMAGe,		"FQIMAGe"),
  EnumToStr_t(INTRN_F4AINT,		"F4AINT"),
  EnumToStr_t(INTRN_F4AINTe,		"F4AINTe"),
  EnumToStr_t(INTRN_F8AINT,		"F8AINT"),
  EnumToStr_t(INTRN_F8AINTe,		"F8AINTe"),
  EnumToStr_t(INTRN_FQAINT,		"FQAINT"),
  EnumToStr_t(INTRN_FQAINTe,		"FQAINTe"),
  EnumToStr_t(INTRN_I2F4INTe,		"I2F4INTe"),
  EnumToStr_t(INTRN_I4F4INTe,		"I4F4INTe"),
  EnumToStr_t(INTRN_I8F4INTe,		"I8F4INTe"),
  EnumToStr_t(INTRN_I2F8IDINTe,		"I2F8IDINTe"),
  EnumToStr_t(INTRN_I4F8IDINTe,		"I4F8IDINTe"),
  EnumToStr_t(INTRN_I8F8IDINTe,		"I8F8IDINTe"),
  EnumToStr_t(INTRN_I2FQIQINTe,		"I2FQIQINTe"),
  EnumToStr_t(INTRN_I4FQIQINTe,		"I4FQIQINTe"),
  EnumToStr_t(INTRN_I8FQIQINTe,		"I8FQIQINTe"),
  EnumToStr_t(INTRN_I2F4NINT,		"I2F4NINT"),
  EnumToStr_t(INTRN_I2F4NINTe,		"I2F4NINTe"),
  EnumToStr_t(INTRN_I4F4NINT,		"I4F4NINT"),
  EnumToStr_t(INTRN_I4F4NINTe,		"I4F4NINTe"),
  EnumToStr_t(INTRN_I8F4NINT,		"I8F4NINT"),
  EnumToStr_t(INTRN_I8F4NINTe,		"I8F4NINTe"),
  EnumToStr_t(INTRN_I2F8IDNINT,		"I2F8IDNINT"),
  EnumToStr_t(INTRN_I2F8IDNINTe,	"I2F8IDNINTe"),
  EnumToStr_t(INTRN_I4F8IDNINT,		"I4F8IDNINT"),
  EnumToStr_t(INTRN_I4F8IDNINTe,	"I4F8IDNINTe"),
  EnumToStr_t(INTRN_I8F8IDNINT,		"I8F8IDNINT"),
  EnumToStr_t(INTRN_I8F8IDNINTe,	"I8F8IDNINTe"),
  EnumToStr_t(INTRN_I2FQIQNINT,		"I2FQIQNINT"),
  EnumToStr_t(INTRN_I2FQIQNINTe,	"I2FQIQNINTe"),
  EnumToStr_t(INTRN_I4FQIQNINT,		"I4FQIQNINT"),
  EnumToStr_t(INTRN_I4FQIQNINTe,	"I4FQIQNINTe"),
  EnumToStr_t(INTRN_I8FQIQNINT,		"I8FQIQNINT"),
  EnumToStr_t(INTRN_I8FQIQNINTe,	"I8FQIQNINTe"),
  EnumToStr_t(INTRN_F4ANINT,		"F4ANINT"),
  EnumToStr_t(INTRN_F4ANINTe,		"F4ANINTe"),
  EnumToStr_t(INTRN_F8ANINT,		"F8ANINT"),
  EnumToStr_t(INTRN_F8ANINTe,		"F8ANINTe"),
  EnumToStr_t(INTRN_FQANINT,		"FQANINT"),
  EnumToStr_t(INTRN_FQANINTe,		"FQANINTe"),
  EnumToStr_t(INTRN_I2BNOTe,		"I2BNOTe"),
  EnumToStr_t(INTRN_I4BNOTe,		"I4BNOTe"),
  EnumToStr_t(INTRN_I8BNOTe,		"I8BNOTe"),
  EnumToStr_t(INTRN_I2BANDe,		"I2BANDe"),
  EnumToStr_t(INTRN_I4BANDe,		"I4BANDe"),
  EnumToStr_t(INTRN_I8BANDe,		"I8BANDe"),
  EnumToStr_t(INTRN_I2BIORe,		"I2BIORe"),
  EnumToStr_t(INTRN_I4BIORe,		"I4BIORe"),
  EnumToStr_t(INTRN_I8BIORe,		"I8BIORe"),
  EnumToStr_t(INTRN_I2BXORe,		"I2BXORe"),
  EnumToStr_t(INTRN_I4BXORe,		"I4BXORe"),
  EnumToStr_t(INTRN_I8BXORe,		"I8BXORe"),
  EnumToStr_t(INTRN_I1BITS,		"I1BITS"),
  EnumToStr_t(INTRN_I2BITS,		"I2BITS"),
  EnumToStr_t(INTRN_I2BITSe,		"I2BITSe"),
  EnumToStr_t(INTRN_I4BITS,		"I4BITS"),
  EnumToStr_t(INTRN_I4BITSe,		"I4BITSe"),
  EnumToStr_t(INTRN_I8BITS,		"I8BITS"),
  EnumToStr_t(INTRN_I8BITSe,		"I8BITSe"),
  EnumToStr_t(INTRN_I1BSET,		"I1BSET"),
  EnumToStr_t(INTRN_I2BSET,		"I2BSET"),
  EnumToStr_t(INTRN_I2BSETe,		"I2BSETe"),
  EnumToStr_t(INTRN_I4BSET,		"I4BSET"),
  EnumToStr_t(INTRN_I4BSETe,		"I4BSETe"),
  EnumToStr_t(INTRN_I8BSET,		"I8BSET"),
  EnumToStr_t(INTRN_I8BSETe,		"I8BSETe"),
  EnumToStr_t(INTRN_I1BCLR,		"I1BCLR"),
  EnumToStr_t(INTRN_I2BCLR,		"I2BCLR"),
  EnumToStr_t(INTRN_I2BCLRe,		"I2BCLRe"),
  EnumToStr_t(INTRN_I4BCLR,		"I4BCLR"),
  EnumToStr_t(INTRN_I4BCLRe,		"I4BCLRe"),
  EnumToStr_t(INTRN_I8BCLR,		"I8BCLR"),
  EnumToStr_t(INTRN_I8BCLRe,		"I8BCLRe"),
  EnumToStr_t(INTRN_I1BTEST,		"I1BTEST"),
  EnumToStr_t(INTRN_I2BTEST,		"I2BTEST"),
  EnumToStr_t(INTRN_I2BTESTe,		"I2BTESTe"),
  EnumToStr_t(INTRN_I4BTEST,		"I4BTEST"),
  EnumToStr_t(INTRN_I4BTESTe,		"I4BTESTe"),
  EnumToStr_t(INTRN_I8BTEST,		"I8BTEST"),
  EnumToStr_t(INTRN_I8BTESTe,		"I8BTESTe"),
  EnumToStr_t(INTRN_I1MVBITS,		"I1MVBITS"),
  EnumToStr_t(INTRN_I2MVBITS,		"I2MVBITS"),
  EnumToStr_t(INTRN_I4MVBITS,		"I4MVBITS"),
  EnumToStr_t(INTRN_I8MVBITS,		"I8MVBITS"),
  EnumToStr_t(INTRN_I1SHL,		"I1SHL"),
  EnumToStr_t(INTRN_I2SHL,		"I2SHL"),
  EnumToStr_t(INTRN_I1SHR,		"I1SHR"),
  EnumToStr_t(INTRN_I2SHR,		"I2SHR"),
  EnumToStr_t(INTRN_I1SHFT,		"I1SHFT"),
  EnumToStr_t(INTRN_I2SHFT,		"I2SHFT"),
  EnumToStr_t(INTRN_I2SHFTe,		"I2SHFTe"),
  EnumToStr_t(INTRN_I4SHFT,		"I4SHFT"),
  EnumToStr_t(INTRN_I4SHFTe,		"I4SHFTe"),
  EnumToStr_t(INTRN_I8SHFT,		"I8SHFT"),
  EnumToStr_t(INTRN_I8SHFTe,		"I8SHFTe"),
  EnumToStr_t(INTRN_I1SHFTC,		"I1SHFTC"),
  EnumToStr_t(INTRN_I2SHFTC,		"I2SHFTC"),
  EnumToStr_t(INTRN_I2SHFTCe,		"I2SHFTCe"),
  EnumToStr_t(INTRN_I4SHFTC,		"I4SHFTC"),
  EnumToStr_t(INTRN_I4SHFTCe,		"I4SHFTCe"),
  EnumToStr_t(INTRN_I8SHFTC,		"I8SHFTC"),
  EnumToStr_t(INTRN_I8SHFTCe,		"I8SHFTCe"),
  EnumToStr_t(INTRN_I4CLEN,		"I4CLEN"),
  EnumToStr_t(INTRN_I4CLENe,		"I4CLENe"),
  EnumToStr_t(INTRN_I4CINDEX,		"I4CINDEX"),
  EnumToStr_t(INTRN_I4CINDEXe,		"I4CINDEXe"),
  EnumToStr_t(INTRN_CLGE,		"CLGE"),
  EnumToStr_t(INTRN_CLGEe,		"CLGEe"),
  EnumToStr_t(INTRN_CLGT,		"CLGT"),
  EnumToStr_t(INTRN_CLGTe,		"CLGTe"),
  EnumToStr_t(INTRN_CLLE,		"CLLE"),
  EnumToStr_t(INTRN_CLLEe,		"CLLEe"),
  EnumToStr_t(INTRN_CLLT,		"CLLT"),
  EnumToStr_t(INTRN_CLLTe,		"CLLTe"),
  EnumToStr_t(INTRN_F4EXP,		"F4EXP"),
  EnumToStr_t(INTRN_F4EXPe,		"F4EXPe"),
  EnumToStr_t(INTRN_F8EXP,		"F8EXP"),
  EnumToStr_t(INTRN_F8EXPe,		"F8EXPe"),
  EnumToStr_t(INTRN_FQEXP,		"FQEXP"),
  EnumToStr_t(INTRN_FQEXPe,		"FQEXPe"),
  EnumToStr_t(INTRN_C4EXP,		"C4EXP"),
  EnumToStr_t(INTRN_C4EXPe,		"C4EXPe"),
  EnumToStr_t(INTRN_C8EXP,		"C8EXP"),
  EnumToStr_t(INTRN_C8EXPe,		"C8EXPe"),
  EnumToStr_t(INTRN_CQEXP,		"CQEXP"),
  EnumToStr_t(INTRN_CQEXPe,		"CQEXPe"),
  EnumToStr_t(INTRN_F4LOG,		"F4LOG"),
  EnumToStr_t(INTRN_F4LOGe,		"F4LOGe"),
  EnumToStr_t(INTRN_F8LOG,		"F8LOG"),
  EnumToStr_t(INTRN_F8LOGe,		"F8LOGe"),
  EnumToStr_t(INTRN_FQLOG,		"FQLOG"),
  EnumToStr_t(INTRN_FQLOGe,		"FQLOGe"),
  EnumToStr_t(INTRN_C4LOG,		"C4LOG"),
  EnumToStr_t(INTRN_C4LOGe,		"C4LOGe"),
  EnumToStr_t(INTRN_C8LOG,		"C8LOG"),
  EnumToStr_t(INTRN_C8LOGe,		"C8LOGe"),
  EnumToStr_t(INTRN_CQLOG,		"CQLOG"),
  EnumToStr_t(INTRN_CQLOGe,		"CQLOGe"),
  EnumToStr_t(INTRN_F4LOG10,		"F4LOG10"),
  EnumToStr_t(INTRN_F4LOG10e,		"F4LOG10e"),
  EnumToStr_t(INTRN_F8LOG10,		"F8LOG10"),
  EnumToStr_t(INTRN_F8LOG10e,		"F8LOG10e"),
  EnumToStr_t(INTRN_FQLOG10,		"FQLOG10"),
  EnumToStr_t(INTRN_FQLOG10e,		"FQLOG10e"),
  EnumToStr_t(INTRN_F4COS,		"F4COS"),
  EnumToStr_t(INTRN_F4COSe,		"F4COSe"),
  EnumToStr_t(INTRN_F8COS,		"F8COS"),
  EnumToStr_t(INTRN_F8COSe,		"F8COSe"),
  EnumToStr_t(INTRN_FQCOS,		"FQCOS"),
  EnumToStr_t(INTRN_FQCOSe,		"FQCOSe"),
  EnumToStr_t(INTRN_C4COS,		"C4COS"),
  EnumToStr_t(INTRN_C4COSe,		"C4COSe"),
  EnumToStr_t(INTRN_C8COS,		"C8COS"),
  EnumToStr_t(INTRN_C8COSe,		"C8COSe"),
  EnumToStr_t(INTRN_CQCOS,		"CQCOS"),
  EnumToStr_t(INTRN_CQCOSe,		"CQCOSe"),
  EnumToStr_t(INTRN_F4SIN,		"F4SIN"),
  EnumToStr_t(INTRN_F4SINe,		"F4SINe"),
  EnumToStr_t(INTRN_F8SIN,		"F8SIN"),
  EnumToStr_t(INTRN_F8SINe,		"F8SINe"),
  EnumToStr_t(INTRN_FQSIN,		"FQSIN"),
  EnumToStr_t(INTRN_FQSINe,		"FQSINe"),
  EnumToStr_t(INTRN_C4SIN,		"C4SIN"),
  EnumToStr_t(INTRN_C4SINe,		"C4SINe"),
  EnumToStr_t(INTRN_C8SIN,		"C8SIN"),
  EnumToStr_t(INTRN_C8SINe,		"C8SINe"),
  EnumToStr_t(INTRN_CQSIN,		"CQSIN"),
  EnumToStr_t(INTRN_CQSINe,		"CQSINe"),
  EnumToStr_t(INTRN_F4CIS,		"F4CIS"),
  EnumToStr_t(INTRN_F4CISe,		"F4CISe"),
  EnumToStr_t(INTRN_F8CIS,		"F8CIS"),
  EnumToStr_t(INTRN_F8CISe,		"F8CISe"),
  EnumToStr_t(INTRN_FQCIS,		"FQCIS"),
  EnumToStr_t(INTRN_FQCISe,		"FQCISe"),
  EnumToStr_t(INTRN_F4TAN,		"F4TAN"),
  EnumToStr_t(INTRN_F4TANe,		"F4TANe"),
  EnumToStr_t(INTRN_F8TAN,		"F8TAN"),
  EnumToStr_t(INTRN_F8TANe,		"F8TANe"),
  EnumToStr_t(INTRN_FQTAN,		"FQTAN"),
  EnumToStr_t(INTRN_FQTANe,		"FQTANe"),
  EnumToStr_t(INTRN_F4COSD,		"F4COSD"),
  EnumToStr_t(INTRN_F4COSDe,		"F4COSDe"),
  EnumToStr_t(INTRN_F8COSD,		"F8COSD"),
  EnumToStr_t(INTRN_F8COSDe,		"F8COSDe"),
  EnumToStr_t(INTRN_FQCOSD,		"FQCOSD"),
  EnumToStr_t(INTRN_FQCOSDe,		"FQCOSDe"),
  EnumToStr_t(INTRN_F4SIND,		"F4SIND"),
  EnumToStr_t(INTRN_F4SINDe,		"F4SINDe"),
  EnumToStr_t(INTRN_F8SIND,		"F8SIND"),
  EnumToStr_t(INTRN_F8SINDe,		"F8SINDe"),
  EnumToStr_t(INTRN_FQSIND,		"FQSIND"),
  EnumToStr_t(INTRN_FQSINDe,		"FQSINDe"),
  EnumToStr_t(INTRN_F4TAND,		"F4TAND"),
  EnumToStr_t(INTRN_F4TANDe,		"F4TANDe"),
  EnumToStr_t(INTRN_F8TAND,		"F8TAND"),
  EnumToStr_t(INTRN_F8TANDe,		"F8TANDe"),
  EnumToStr_t(INTRN_FQTAND,		"FQTAND"),
  EnumToStr_t(INTRN_FQTANDe,		"FQTANDe"),
  EnumToStr_t(INTRN_F4COSH,		"F4COSH"),
  EnumToStr_t(INTRN_F4COSHe,		"F4COSHe"),
  EnumToStr_t(INTRN_F8COSH,		"F8COSH"),
  EnumToStr_t(INTRN_F8COSHe,		"F8COSHe"),
  EnumToStr_t(INTRN_FQCOSH,		"FQCOSH"),
  EnumToStr_t(INTRN_FQCOSHe,		"FQCOSHe"),
  EnumToStr_t(INTRN_F4SINH,		"F4SINH"),
  EnumToStr_t(INTRN_F4SINHe,		"F4SINHe"),
  EnumToStr_t(INTRN_F8SINH,		"F8SINH"),
  EnumToStr_t(INTRN_F8SINHe,		"F8SINHe"),
  EnumToStr_t(INTRN_FQSINH,		"FQSINH"),
  EnumToStr_t(INTRN_FQSINHe,		"FQSINHe"),
  EnumToStr_t(INTRN_F4TANH,		"F4TANH"),
  EnumToStr_t(INTRN_F4TANHe,		"F4TANHe"),
  EnumToStr_t(INTRN_F8TANH,		"F8TANH"),
  EnumToStr_t(INTRN_F8TANHe,		"F8TANHe"),
  EnumToStr_t(INTRN_FQTANH,		"FQTANH"),
  EnumToStr_t(INTRN_FQTANHe,		"FQTANHe"),
  EnumToStr_t(INTRN_F4ACOS,		"F4ACOS"),
  EnumToStr_t(INTRN_F4ACOSe,		"F4ACOSe"),
  EnumToStr_t(INTRN_F8ACOS,		"F8ACOS"),
  EnumToStr_t(INTRN_F8ACOSe,		"F8ACOSe"),
  EnumToStr_t(INTRN_FQACOS,		"FQACOS"),
  EnumToStr_t(INTRN_FQACOSe,		"FQACOSe"),
  EnumToStr_t(INTRN_F4ASIN,		"F4ASIN"),
  EnumToStr_t(INTRN_F4ASINe,		"F4ASINe"),
  EnumToStr_t(INTRN_F8ASIN,		"F8ASIN"),
  EnumToStr_t(INTRN_F8ASINe,		"F8ASINe"),
  EnumToStr_t(INTRN_FQASIN,		"FQASIN"),
  EnumToStr_t(INTRN_FQASINe,		"FQASINe"),
  EnumToStr_t(INTRN_F4ATAN,		"F4ATAN"),
  EnumToStr_t(INTRN_F4ATANe,		"F4ATANe"),
  EnumToStr_t(INTRN_F8ATAN,		"F8ATAN"),
  EnumToStr_t(INTRN_F8ATANe,		"F8ATANe"),
  EnumToStr_t(INTRN_FQATAN,		"FQATAN"),
  EnumToStr_t(INTRN_FQATANe,		"FQATANe"),
  EnumToStr_t(INTRN_F4ACOSD,		"F4ACOSD"),
  EnumToStr_t(INTRN_F4ACOSDe,		"F4ACOSDe"),
  EnumToStr_t(INTRN_F8ACOSD,		"F8ACOSD"),
  EnumToStr_t(INTRN_F8ACOSDe,		"F8ACOSDe"),
  EnumToStr_t(INTRN_FQACOSD,		"FQACOSD"),
  EnumToStr_t(INTRN_FQACOSDe,		"FQACOSDe"),
  EnumToStr_t(INTRN_F4ASIND,		"F4ASIND"),
  EnumToStr_t(INTRN_F4ASINDe,		"F4ASINDe"),
  EnumToStr_t(INTRN_F8ASIND,		"F8ASIND"),
  EnumToStr_t(INTRN_F8ASINDe,		"F8ASINDe"),
  EnumToStr_t(INTRN_FQASIND,		"FQASIND"),
  EnumToStr_t(INTRN_FQASINDe,		"FQASINDe"),
  EnumToStr_t(INTRN_F4ATAND,		"F4ATAND"),
  EnumToStr_t(INTRN_F4ATANDe,		"F4ATANDe"),
  EnumToStr_t(INTRN_F8ATAND,		"F8ATAND"),
  EnumToStr_t(INTRN_F8ATANDe,		"F8ATANDe"),
  EnumToStr_t(INTRN_FQATAND,		"FQATAND"),
  EnumToStr_t(INTRN_FQATANDe,		"FQATANDe"),
  EnumToStr_t(INTRN_F4ATAN2,		"F4ATAN2"),
  EnumToStr_t(INTRN_F4ATAN2e,		"F4ATAN2e"),
  EnumToStr_t(INTRN_F8ATAN2,		"F8ATAN2"),
  EnumToStr_t(INTRN_F8ATAN2e,		"F8ATAN2e"),
  EnumToStr_t(INTRN_FQATAN2,		"FQATAN2"),
  EnumToStr_t(INTRN_FQATAN2e,		"FQATAN2e"),
  EnumToStr_t(INTRN_F4ATAN2D,		"F4ATAN2D"),
  EnumToStr_t(INTRN_F4ATAN2De,		"F4ATAN2De"),
  EnumToStr_t(INTRN_F8ATAN2D,		"F8ATAN2D"),
  EnumToStr_t(INTRN_F8ATAN2De,		"F8ATAN2De"),
  EnumToStr_t(INTRN_FQATAN2D,		"FQATAN2D"),
  EnumToStr_t(INTRN_FQATAN2De,		"FQATAN2De"),
  EnumToStr_t(INTRN_U4I4ALLOCA,		"U4I4ALLOCA"),
  EnumToStr_t(INTRN_U8I8ALLOCA,		"U8I8ALLOCA"),
  EnumToStr_t(INTRN_U4I4MALLOC,		"U4I4MALLOC"),
  EnumToStr_t(INTRN_U8I8MALLOC,		"U8I8MALLOC"),
  EnumToStr_t(INTRN_U4FREE,		"U4FREE"),
  EnumToStr_t(INTRN_U8FREE,		"U8FREE"),
  EnumToStr_t(INTRN_MDATE,		"MDATE"),
  EnumToStr_t(INTRN_I1DATE,		"I1DATE"),
  EnumToStr_t(INTRN_I2DATE,		"I2DATE"),
  EnumToStr_t(INTRN_I4DATE,		"I4DATE"),
  EnumToStr_t(INTRN_I8DATE,		"I8DATE"),
  EnumToStr_t(INTRN_I1ERRSNS,		"I1ERRSNS"),
  EnumToStr_t(INTRN_I2ERRSNS,		"I2ERRSNS"),
  EnumToStr_t(INTRN_I4ERRSNS,		"I4ERRSNS"),
  EnumToStr_t(INTRN_I8ERRSNS,		"I8ERRSNS"),
  EnumToStr_t(INTRN_VEXIT,		"VEXIT"),
  EnumToStr_t(INTRN_I1EXIT,		"I1EXIT"),
  EnumToStr_t(INTRN_I2EXIT,		"I2EXIT"),
  EnumToStr_t(INTRN_I4EXIT,		"I4EXIT"),
  EnumToStr_t(INTRN_I8EXIT,		"I8EXIT"),
  EnumToStr_t(INTRN_TIME,		"TIME"),
  EnumToStr_t(INTRN_F4SECNDS,		"F4SECNDS"),
  EnumToStr_t(INTRN_F8SECNDS,		"F8SECNDS"),
  EnumToStr_t(INTRN_PAUSE,		"PAUSE"),
  EnumToStr_t(INTRN_STOP,		"STOP"),
  EnumToStr_t(INTRN_F4I4RAN,		"F4I4RAN"),
  EnumToStr_t(INTRN_F4I8RAN,		"F4I8RAN"),
  EnumToStr_t(INTRN_F8I4RAN,		"F8I4RAN"),
  EnumToStr_t(INTRN_F8I8RAN,		"F8I8RAN"),
  EnumToStr_t(INTRN_FQI4RAN,		"FQI4RAN"),
  EnumToStr_t(INTRN_FQI8RAN,		"FQI8RAN"),
  EnumToStr_t(INTRN_I4DIVFLOOR,		"I4DIVFLOOR"),
  EnumToStr_t(INTRN_I8DIVFLOOR,		"I8DIVFLOOR"),
  EnumToStr_t(INTRN_U4DIVFLOOR,		"U4DIVFLOOR"),
  EnumToStr_t(INTRN_U8DIVFLOOR,		"U8DIVFLOOR"),
  EnumToStr_t(INTRN_I4DIVCEIL,		"I4DIVCEIL"),
  EnumToStr_t(INTRN_I8DIVCEIL,		"I8DIVCEIL"),
  EnumToStr_t(INTRN_U4DIVCEIL,		"U4DIVCEIL"),
  EnumToStr_t(INTRN_U8DIVCEIL,		"U8DIVCEIL"),
  EnumToStr_t(INTRN_I4MODFLOOR,		"I4MODFLOOR"),
  EnumToStr_t(INTRN_I8MODFLOOR,		"I8MODFLOOR"),
  EnumToStr_t(INTRN_U4MODFLOOR,		"U4MODFLOOR"),
  EnumToStr_t(INTRN_U8MODFLOOR,		"U8MODFLOOR"),
  EnumToStr_t(INTRN_I4MODCEIL,		"I4MODCEIL"),
  EnumToStr_t(INTRN_I8MODCEIL,		"I8MODCEIL"),
  EnumToStr_t(INTRN_U4MODCEIL,		"U4MODCEIL"),
  EnumToStr_t(INTRN_U8MODCEIL,		"U8MODCEIL"),
  EnumToStr_t(INTRN_U4I4SETSTACKPOINTER,"U4I4SETSTACKPOINTER"),
  EnumToStr_t(INTRN_U8I8SETSTACKPOINTER,"U8I8SETSTACKPOINTER"),
  EnumToStr_t(INTRN_U4READSTACKPOINTER,	"U4READSTACKPOINTER"),
  EnumToStr_t(INTRN_U8READSTACKPOINTER,	"U8READSTACKPOINTER"),
  EnumToStr_t(INTRN_ADD_AND_FETCH_I4,	"ADD_AND_FETCH_I4"),
  EnumToStr_t(INTRN_SUB_AND_FETCH_I4,	"SUB_AND_FETCH_I4"),
  EnumToStr_t(INTRN_OR_AND_FETCH_I4,	"OR_AND_FETCH_I4"),
  EnumToStr_t(INTRN_XOR_AND_FETCH_I4,	"XOR_AND_FETCH_I4"),
  EnumToStr_t(INTRN_AND_AND_FETCH_I4,	"AND_AND_FETCH_I4"),
  EnumToStr_t(INTRN_NAND_AND_FETCH_I4,	"NAND_AND_FETCH_I4"),
  EnumToStr_t(INTRN_FETCH_AND_ADD_I4,	"FETCH_AND_ADD_I4"),
  EnumToStr_t(INTRN_FETCH_AND_SUB_I4,	"FETCH_AND_SUB_I4"),
  EnumToStr_t(INTRN_FETCH_AND_OR_I4,	"FETCH_AND_OR_I4"),
  EnumToStr_t(INTRN_FETCH_AND_XOR_I4,	"FETCH_AND_XOR_I4"),
  EnumToStr_t(INTRN_FETCH_AND_AND_I4,	"FETCH_AND_AND_I4"),
  EnumToStr_t(INTRN_FETCH_AND_NAND_I4,	"FETCH_AND_NAND_I4"),
  EnumToStr_t(INTRN_ADD_AND_FETCH_I8,	"ADD_AND_FETCH_I8"),
  EnumToStr_t(INTRN_SUB_AND_FETCH_I8,	"SUB_AND_FETCH_I8"),
  EnumToStr_t(INTRN_OR_AND_FETCH_I8,	"OR_AND_FETCH_I8"),
  EnumToStr_t(INTRN_XOR_AND_FETCH_I8,	"XOR_AND_FETCH_I8"),
  EnumToStr_t(INTRN_AND_AND_FETCH_I8,	"AND_AND_FETCH_I8"),
  EnumToStr_t(INTRN_NAND_AND_FETCH_I8,	"NAND_AND_FETCH_I8"),
  EnumToStr_t(INTRN_FETCH_AND_ADD_I8,	"FETCH_AND_ADD_I8"),
  EnumToStr_t(INTRN_FETCH_AND_SUB_I8,	"FETCH_AND_SUB_I8"),
  EnumToStr_t(INTRN_FETCH_AND_OR_I8,	"FETCH_AND_OR_I8"),
  EnumToStr_t(INTRN_FETCH_AND_XOR_I8,	"FETCH_AND_XOR_I8"),
  EnumToStr_t(INTRN_FETCH_AND_AND_I8,	"FETCH_AND_AND_I8"),
  EnumToStr_t(INTRN_FETCH_AND_NAND_I8,	"FETCH_AND_NAND_I8"),
  EnumToStr_t(INTRN_LOCK_TEST_AND_SET_I4,"LOCK_TEST_AND_SET_I4"),
  EnumToStr_t(INTRN_LOCK_TEST_AND_SET_I8,"LOCK_TEST_AND_SET_I8"),
  EnumToStr_t(INTRN_LOCK_RELEASE_I4,	"LOCK_RELEASE_I4"),
  EnumToStr_t(INTRN_LOCK_RELEASE_I8,	"LOCK_RELEASE_I8"),
  EnumToStr_t(INTRN_COMPARE_AND_SWAP_I4,"COMPARE_AND_SWAP_I4"),
  EnumToStr_t(INTRN_COMPARE_AND_SWAP_I8,"COMPARE_AND_SWAP_I8"),
  EnumToStr_t(INTRN_SYNCHRONIZE,	"SYNCHRONIZE"),
  EnumToStr_t(INTRN_RETURN_ADDRESS,	"RETURN_ADDRESS"),
  EnumToStr_t(INTRN_U4I1ADRTMP,		"U4I1ADRTMP"),
  EnumToStr_t(INTRN_U4I2ADRTMP,		"U4I2ADRTMP"),
  EnumToStr_t(INTRN_U4I4ADRTMP,		"U4I4ADRTMP"),
  EnumToStr_t(INTRN_U4I8ADRTMP,		"U4I8ADRTMP"),
  EnumToStr_t(INTRN_U4F4ADRTMP,		"U4F4ADRTMP"),
  EnumToStr_t(INTRN_U4F8ADRTMP,		"U4F8ADRTMP"),
  EnumToStr_t(INTRN_U4FQADRTMP,		"U4FQADRTMP"),
  EnumToStr_t(INTRN_U4C4ADRTMP,		"U4C4ADRTMP"),
  EnumToStr_t(INTRN_U4C8ADRTMP,		"U4C8ADRTMP"),
  EnumToStr_t(INTRN_U4CQADRTMP,		"U4CQADRTMP"),
  EnumToStr_t(INTRN_U4VADRTMP,		"U4VADRTMP"),
  EnumToStr_t(INTRN_U8I1ADRTMP,		"U8I1ADRTMP"),
  EnumToStr_t(INTRN_U8I2ADRTMP,		"U8I2ADRTMP"),
  EnumToStr_t(INTRN_U8I4ADRTMP,		"U8I4ADRTMP"),
  EnumToStr_t(INTRN_U8I8ADRTMP,		"U8I8ADRTMP"),
  EnumToStr_t(INTRN_U8F4ADRTMP,		"U8F4ADRTMP"),
  EnumToStr_t(INTRN_U8F8ADRTMP,		"U8F8ADRTMP"),
  EnumToStr_t(INTRN_U8FQADRTMP,		"U8FQADRTMP"),
  EnumToStr_t(INTRN_U8C4ADRTMP,		"U8C4ADRTMP"),
  EnumToStr_t(INTRN_U8C8ADRTMP,		"U8C8ADRTMP"),
  EnumToStr_t(INTRN_U8CQADRTMP,		"U8CQADRTMP"),
  EnumToStr_t(INTRN_U8VADRTMP,		"U8VADRTMP"),
  EnumToStr_t(INTRN_I4VALTMP,		"I4VALTMP"),
  EnumToStr_t(INTRN_I8VALTMP,		"I8VALTMP"),
  EnumToStr_t(INTRN_U4VALTMP,		"U4VALTMP"),
  EnumToStr_t(INTRN_U8VALTMP,		"U8VALTMP"),
  EnumToStr_t(INTRN_F4VALTMP,		"F4VALTMP"),
  EnumToStr_t(INTRN_F8VALTMP,		"F8VALTMP"),
  EnumToStr_t(INTRN_FQVALTMP,		"FQVALTMP"),
  EnumToStr_t(INTRN_C4VALTMP,		"C4VALTMP"),
  EnumToStr_t(INTRN_C8VALTMP,		"C8VALTMP"),
  EnumToStr_t(INTRN_CQVALTMP,		"CQVALTMP"),
  EnumToStr_t(INTRN_BCOPY,		"BCOPY"),
  EnumToStr_t(INTRN_BCMP,		"BCMP"),
  EnumToStr_t(INTRN_BZERO,		"BZERO"),
  EnumToStr_t(INTRN_MEMCCPY,		"MEMCCPY"),
  EnumToStr_t(INTRN_MEMCHR,		"MEMCHR"),
  EnumToStr_t(INTRN_MEMCMP,		"MEMCMP"),
  EnumToStr_t(INTRN_MEMCPY,		"MEMCPY"),
  EnumToStr_t(INTRN_MEMMOVE,		"MEMMOVE"),
  EnumToStr_t(INTRN_MEMSET,		"MEMSET"),
  EnumToStr_t(INTRN_STRCMP,		"STRCMP"),
  EnumToStr_t(INTRN_STRNCMP,		"STRNCMP"),
  EnumToStr_t(INTRN_STRCPY,		"STRCPY"),
  EnumToStr_t(INTRN_STRNCPY,		"STRNCPY"),
  EnumToStr_t(INTRN_STRLEN,		"STRLEN"),
  EnumToStr_t(INTRN_PRINTF,		"PRINTF"),
  EnumToStr_t(INTRN_FPRINTF,		"FPRINTF"),
  EnumToStr_t(INTRN_SPRINTF,		"SPRINTF"),
  EnumToStr_t(INTRN_PRINTW,		"PRINTW"),
  EnumToStr_t(INTRN_SCANF,		"SCANF"),
  EnumToStr_t(INTRN_FSCANF,		"FSCANF"),
  EnumToStr_t(INTRN_SSCANF,		"SSCANF"),
  EnumToStr_t(INTRN_FPUTC,		"FPUTC"),
  EnumToStr_t(INTRN_FPUTS,		"FPUTS"),
  EnumToStr_t(INTRN_FGETC,		"FGETC"),
  EnumToStr_t(INTRN_FGETS,		"FGETS"),
  EnumToStr_t(INTRN_F4VACOS,		"F4VACOS"),
  EnumToStr_t(INTRN_F8VACOS,		"F8VACOS"),
  EnumToStr_t(INTRN_F4VASIN,		"F4VASIN"),
  EnumToStr_t(INTRN_F8VASIN,		"F8VASIN"),
  EnumToStr_t(INTRN_F4VATAN,		"F4VATAN"),
  EnumToStr_t(INTRN_F8VATAN,		"F8VATAN"),
  EnumToStr_t(INTRN_F4VCOS,		"F4VCOS"),
  EnumToStr_t(INTRN_F8VCOS,		"F8VCOS"),
  EnumToStr_t(INTRN_F4VEXP,		"F4VEXP"),
  EnumToStr_t(INTRN_F8VEXP,		"F8VEXP"),
  EnumToStr_t(INTRN_F4VLOG,		"F4VLOG"),
  EnumToStr_t(INTRN_F8VLOG,		"F8VLOG"),
  EnumToStr_t(INTRN_F4VSIN,		"F4VSIN"),
  EnumToStr_t(INTRN_F8VSIN,		"F8VSIN"),
  EnumToStr_t(INTRN_F4VSQRT,		"F4VSQRT"),
  EnumToStr_t(INTRN_F8VSQRT,		"F8VSQRT"),
  EnumToStr_t(INTRN_F4VTAN,		"F4VTAN"),
  EnumToStr_t(INTRN_F8VTAN,		"F8VTAN"),
  EnumToStr_t(INTRN_NARY_ADD,		"NARY_ADD"),
  EnumToStr_t(INTRN_NARY_MPY,		"NARY_MPY"),
  EnumToStr_t(INTRN_U4I4TRAPUV_MALLOC,	"U4I4TRAPUV_MALLOC"),
  EnumToStr_t(INTRN_U8I8TRAPUV_MALLOC,	"U8I8TRAPUV_MALLOC"),
  EnumToStr_t(INTRN_F77_BOUNDS_ERR,	"F77_BOUNDS_ERR"),
  EnumToStr_t(INTRN_DSM_NUMTHREADS,	"DSM_NUMTHREADS"),
  EnumToStr_t(INTRN_DSM_CHUNKSIZE,	"DSM_CHUNKSIZE"),
  EnumToStr_t(INTRN_DSM_THIS_CHUNKSIZE,	"DSM_THIS_CHUNKSIZE"),
  EnumToStr_t(INTRN_DSM_REM_CHUNKSIZE,	"DSM_REM_CHUNKSIZE"),
  EnumToStr_t(INTRN_DSM_NUMCHUNKS,	"DSM_NUMCHUNKS"),
  EnumToStr_t(INTRN_DSM_THIS_THREADNUM,	"DSM_THIS_THREADNUM"),
  EnumToStr_t(INTRN_DSM_DISTRIBUTION_BLOCK,	"DSM_DISTRIBUTION_BLOCK"),
  EnumToStr_t(INTRN_DSM_DISTRIBUTION_STAR,	"DSM_DISTRIBUTION_STAR"),
  EnumToStr_t(INTRN_DSM_ISRESHAPED,		"DSM_ISRESHAPED"),
  EnumToStr_t(INTRN_DSM_ISDISTRIBUTED,		"DSM_ISDISTRIBUTED"),
  EnumToStr_t(INTRN_DSM_THIS_STARTINDEX,	"DSM_THIS_STARTINDEX"),
  EnumToStr_t(INTRN_DSM_DISTRIBUTION_CYCLIC,	"DSM_DISTRIBUTION_CYCLIC"),
  EnumToStr_t(INTRN_MPY_AND_FETCH_I4,	"MPY_AND_FETCH_I4"),
  EnumToStr_t(INTRN_MIN_AND_FETCH_I4,	"MIN_AND_FETCH_I4"),
  EnumToStr_t(INTRN_MAX_AND_FETCH_I4,	"MAX_AND_FETCH_I4"),
  EnumToStr_t(INTRN_FETCH_AND_MPY_I4,	"FETCH_AND_MPY_I4"),
  EnumToStr_t(INTRN_FETCH_AND_MIN_I4,	"FETCH_AND_MIN_I4"),
  EnumToStr_t(INTRN_FETCH_AND_MAX_I4,	"FETCH_AND_MAX_I4"),
  EnumToStr_t(INTRN_MPY_AND_FETCH_I8,	"MPY_AND_FETCH_I8"),
  EnumToStr_t(INTRN_MIN_AND_FETCH_I8,	"MIN_AND_FETCH_I8"),
  EnumToStr_t(INTRN_MAX_AND_FETCH_I8,	"MAX_AND_FETCH_I8"),
  EnumToStr_t(INTRN_FETCH_AND_MPY_I8,	"FETCH_AND_MPY_I8"),
  EnumToStr_t(INTRN_FETCH_AND_MIN_I8,	"FETCH_AND_MIN_I8"),
  EnumToStr_t(INTRN_FETCH_AND_MAX_I8,	"FETCH_AND_MAX_I8"),
  EnumToStr_t(INTRN_ADD_AND_FETCH_F4,	"ADD_AND_FETCH_F4"),
  EnumToStr_t(INTRN_SUB_AND_FETCH_F4,	"SUB_AND_FETCH_F4"),
  EnumToStr_t(INTRN_OR_AND_FETCH_F4,	"OR_AND_FETCH_F4"),
  EnumToStr_t(INTRN_XOR_AND_FETCH_F4,	"XOR_AND_FETCH_F4"),
  EnumToStr_t(INTRN_AND_AND_FETCH_F4,	"AND_AND_FETCH_F4"),
  EnumToStr_t(INTRN_NAND_AND_FETCH_F4,	"NAND_AND_FETCH_F4"),
  EnumToStr_t(INTRN_MPY_AND_FETCH_F4,	"MPY_AND_FETCH_F4"),
  EnumToStr_t(INTRN_MIN_AND_FETCH_F4,	"MIN_AND_FETCH_F4"),
  EnumToStr_t(INTRN_MAX_AND_FETCH_F4,	"MAX_AND_FETCH_F4"),
  EnumToStr_t(INTRN_FETCH_AND_ADD_F4,	"FETCH_AND_ADD_F4"),
  EnumToStr_t(INTRN_FETCH_AND_SUB_F4,	"FETCH_AND_SUB_F4"),
  EnumToStr_t(INTRN_FETCH_AND_OR_F4,	"FETCH_AND_OR_F4"),
  EnumToStr_t(INTRN_FETCH_AND_XOR_F4,	"FETCH_AND_XOR_F4"),
  EnumToStr_t(INTRN_FETCH_AND_AND_F4,	"FETCH_AND_AND_F4"),
  EnumToStr_t(INTRN_FETCH_AND_NAND_F4,	"FETCH_AND_NAND_F4"),
  EnumToStr_t(INTRN_FETCH_AND_MPY_F4,	"FETCH_AND_MPY_F4"),
  EnumToStr_t(INTRN_FETCH_AND_MIN_F4,	"FETCH_AND_MIN_F4"),
  EnumToStr_t(INTRN_FETCH_AND_MAX_F4,	"FETCH_AND_MAX_F4"),
  EnumToStr_t(INTRN_ADD_AND_FETCH_F8,	"ADD_AND_FETCH_F8"),
  EnumToStr_t(INTRN_SUB_AND_FETCH_F8,	"SUB_AND_FETCH_F8"),
  EnumToStr_t(INTRN_OR_AND_FETCH_F8,	"OR_AND_FETCH_F8"),
  EnumToStr_t(INTRN_XOR_AND_FETCH_F8,	"XOR_AND_FETCH_F8"),
  EnumToStr_t(INTRN_AND_AND_FETCH_F8,	"AND_AND_FETCH_F8"),
  EnumToStr_t(INTRN_NAND_AND_FETCH_F8,	"NAND_AND_FETCH_F8"),
  EnumToStr_t(INTRN_MPY_AND_FETCH_F8,	"MPY_AND_FETCH_F8"),
  EnumToStr_t(INTRN_MIN_AND_FETCH_F8,	"MIN_AND_FETCH_F8"),
  EnumToStr_t(INTRN_MAX_AND_FETCH_F8,	"MAX_AND_FETCH_F8"),
  EnumToStr_t(INTRN_FETCH_AND_ADD_F8,	"FETCH_AND_ADD_F8"),
  EnumToStr_t(INTRN_FETCH_AND_SUB_F8,	"FETCH_AND_SUB_F8"),
  EnumToStr_t(INTRN_FETCH_AND_OR_F8,	"FETCH_AND_OR_F8"),
  EnumToStr_t(INTRN_FETCH_AND_XOR_F8,	"FETCH_AND_XOR_F8"),
  EnumToStr_t(INTRN_FETCH_AND_AND_F8,	"FETCH_AND_AND_F8"),
  EnumToStr_t(INTRN_FETCH_AND_NAND_F8,	"FETCH_AND_NAND_F8"),
  EnumToStr_t(INTRN_FETCH_AND_MPY_F8,	"FETCH_AND_MPY_F8"),
  EnumToStr_t(INTRN_FETCH_AND_MIN_F8,	"FETCH_AND_MIN_F8"),
  EnumToStr_t(INTRN_FETCH_AND_MAX_F8,	"FETCH_AND_MAX_F8"),
  EnumToStr_t(INTRN_LOCK_ACQUIRE_I4,	"LOCK_ACQUIRE_I4"),
  EnumToStr_t(INTRN_LOCK_ACQUIRE_I8,	"LOCK_ACQUIRE_I8"),
  EnumToStr_t(INTRN_F90_STACKTEMPALLOC,	"F90_STACKTEMPALLOC"),
  EnumToStr_t(INTRN_F90_HEAPTEMPALLOC,	"F90_HEAPTEMPALLOC"),
  EnumToStr_t(INTRN_F90_STACKTEMPFREE,	"F90_STACKTEMPFREE"),
  EnumToStr_t(INTRN_F90_HEAPTEMPFREE,	"F90_HEAPTEMPFREE"),

  /* Automatically generated F90 intrinsic definitions */

#include "wutil90.h"

  EnumToStr_t(INTRN_MP_IN_PARALLEL_REGION,	"MP_IN_PARALLEL_REGION"), 
  EnumToStr_t(INTRN_RT_ERR,		"RT_ERR"), 
  EnumToStr_t(INTRN_OMP_DO_WORKSHARING,	"OMP_DO_WORKSHARING"),
  EnumToStr_t(INTRN_OMP_TEST_LOCK,	"OMP_TEST_LOCK"),
  EnumToStr_t(INTRN_OMP_GET_NUM_THREADS,"OMP_GET_NUM_THREADS"),
  EnumToStr_t(INTRN_OMP_GET_MAX_THREADS,"OMP_GET_MAX_THREADS"),
  EnumToStr_t(INTRN_OMP_GET_THREAD_NUM,	"OMP_GET_THREAD_NUM"),
  EnumToStr_t(INTRN_OMP_GET_NUM_PROCS,	"OMP_GET_NUM_PROCS"),
  EnumToStr_t(INTRN_OMP_IN_PARALLEL,	"OMP_IN_PARALLEL"),
  EnumToStr_t(INTRN_OMP_GET_DYNAMIC,	"OMP_GET_DYNAMIC"),
  EnumToStr_t(INTRN_OMP_GET_NESTED,	"OMP_GET_NESTED"),
    EnumToStr_t(INTRN_I1IEEE_INT,	"I1IEEE_INT"),
    EnumToStr_t(INTRN_I2IEEE_INT, 	"I2IEEE_INT"),
    EnumToStr_t(INTRN_I4IEEE_INT,	"I4IEEE_INT"),
    EnumToStr_t(INTRN_I8IEEE_INT,	"I8IEEE_INT"),
    EnumToStr_t(INTRN_F4IEEE_INT,	"F4IEEE_INT"),
    EnumToStr_t(INTRN_F8IEEE_INT,	"F8IEEE_INT"),
    EnumToStr_t(INTRN_FQIEEE_INT, 	"FQIEEE_INT"),
    EnumToStr_t(INTRN_F90BOUNDS_CHECK,	"F90BOUNDS_CHECK"),
  EnumToStr_t(INTRN_F90_DYNAMICTEMPALLOC,	"F90_DYNAMICTEMPALLOC"),
  EnumToStr_t(INTRN_F90_DYNAMICTEMPFREE,	"F90_DYNAMICTEMPFREE"),
  EnumToStr_t(INTRN_F90CONFORM_CHECK,		"F90CONFORM_CHECK"),
  
  EnumToStr_t(INTRN_C_F4FLOOR,		"C_F4FLOOR"),
  EnumToStr_t(INTRN_C_F8FLOOR,		"C_F8FLOOR"),
  EnumToStr_t(INTRN_C_FQFLOOR,		"C_FQFLOOR"),
  EnumToStr_t(INTRN_C_F4CEIL,		"C_F4CEIL"),
  EnumToStr_t(INTRN_C_F8CEIL,		"C_F8CEIL"),
  EnumToStr_t(INTRN_C_FQCEIL,		"C_FQCEIL"),
  EnumToStr_t(INTRN_C_F4TRUNC,		"C_F4TRUNC"),
  EnumToStr_t(INTRN_C_F8TRUNC,		"C_F8TRUNC"),
  EnumToStr_t(INTRN_C_FQTRUNC,		"C_FQTRUNC"),

  EnumToStr_t(INTRN_I4DSHIFTL,		"I4DSHIFTL"),
  EnumToStr_t(INTRN_I8DSHIFTL,		"I8DSHIFTL"),
  EnumToStr_t(INTRN_I4DSHIFTR,		"I4DSHIFTR"),
  EnumToStr_t(INTRN_I8DSHIFTR,		"I8DSHIFTR"),
  EnumToStr_t(INTRN_I4GBIT,		"I4GBIT"),
  EnumToStr_t(INTRN_I8GBIT,		"I8GBIT"),
  EnumToStr_t(INTRN_I4GBITS,		"I4GBITS"),
  EnumToStr_t(INTRN_I8GBITS,		"I8GBITS"),
  EnumToStr_t(INTRN_I4MASK,		"I4MASK"),
  EnumToStr_t(INTRN_I8MASK,		"I8MASK"),
  EnumToStr_t(INTRN_I4MASKL,		"I4MASKL"),
  EnumToStr_t(INTRN_I8MASKL,		"I8MASKL"),
  EnumToStr_t(INTRN_I4MASKR,		"I4MASKR"),
  EnumToStr_t(INTRN_I8MASKR,		"I8MASKR"),
  EnumToStr_t(INTRN_I4PBIT,		"I4PBIT"),
  EnumToStr_t(INTRN_I8PBIT,		"I8PBIT"),
  EnumToStr_t(INTRN_I4PBITS,		"I4PBITS"),
  EnumToStr_t(INTRN_I8PBITS,		"I8PBITS"),
  EnumToStr_t(INTRN_I4POPPAR,		"I4POPPAR"),
  EnumToStr_t(INTRN_I8POPPAR,		"I8POPPAR"),
  EnumToStr_t(INTRN_I4RTC,		"I4RTC"),
  EnumToStr_t(INTRN_I8RTC,		"I8RTC"),

  EnumToStr_t(INTRN_GETF_EXP,		"GETF_EXP"),
  EnumToStr_t(INTRN_SETF_EXP,		"SETF_EXP"),
  EnumToStr_t(INTRN_GETF_SIG,		"GETF_SIG"),
  EnumToStr_t(INTRN_SETF_SIG,		"SETF_SIG"),

  EnumToStr_t(INTRN_FMERGE_NS,		"FMERGE_NS"),
  EnumToStr_t(INTRN_FMERGE_S,		"FMERGE_S"),
  EnumToStr_t(INTRN_FMERGE_SE,		"FMERGE_SE"),
  EnumToStr_t(INTRN_STOP_F90,		"STOP_F90"),

  EnumToStr_t(INTRN_F4VLOG10,		"F4VLOG10"),
  EnumToStr_t(INTRN_F8VLOG10,		"F8VLOG10"),

  EnumToStr_t(INTRN_MODSI3,		"MODSI3"),
  EnumToStr_t(INTRN_UMODSI3,		"UMODSI3"),
  EnumToStr_t(INTRN_DIVSI3,		"DIVSI3"),
  EnumToStr_t(INTRN_UDIVSI3,		"UDIVSI3"),
  EnumToStr_t(INTRN_MODDI3,		"MODDI3"),
  EnumToStr_t(INTRN_UMODDI3,		"UMODDI3"),
  EnumToStr_t(INTRN_DIVDI3,		"DIVDI3"),
  EnumToStr_t(INTRN_UDIVDI3,		"UDIVDI3"),
  EnumToStr_t(INTRN_DIVSF3,		"DIVSF3"),
  EnumToStr_t(INTRN_DIVDF3,		"DIVDF3"),

  EnumToStr_t(INTRN_I4FFS,		"I4FFS"),

  EnumToStr_t(INTRN_SINCOSF,		"SINCOSF"),
  EnumToStr_t(INTRN_SINCOS,		"SINCOS"),
  EnumToStr_t(INTRN_SINCOSL,		"SINCOSL"),
  
  /* UPC specific */
  /* UPC blocking loads */
  EnumToStr_t(INTRN_SILD,		"S_I1LD"),
  EnumToStr_t(INTRN_SF4LD,		"S_F4LD"),
  EnumToStr_t(INTRN_SF8LD,		"S_F8LD"),
  EnumToStr_t(INTRN_SMLD,		"S_MLD"),
  /* UPC blocking  stores */
  EnumToStr_t(INTRN_SIST,		"S_IST"),
  EnumToStr_t(INTRN_SF4ST,		"S_F4ST"),
  EnumToStr_t(INTRN_SF8ST,		"S_F8ST"),
  EnumToStr_t(INTRN_SMST,		"S_MST"),
 
  /* UPC non-blocking loads */
  EnumToStr_t(INTRN_SILD_NB,		"S_ILD_NB"),
  EnumToStr_t(INTRN_SF4LD_NB,		"S_F4LD_NB"),
  EnumToStr_t(INTRN_SF8LD_NB,		"LALA"),
  EnumToStr_t(INTRN_SMLD_NB,		"S_MLD_NB"),

  /* UPC non-blocking strores */
  EnumToStr_t(INTRN_SIST_NB,		"S_IST_NB"),
  EnumToStr_t(INTRN_SF4ST_NB,		"S_F4ST_NB"),
  EnumToStr_t(INTRN_SF8ST_NB,		"S_F8ST_NB"),
  EnumToStr_t(INTRN_SMST_NB,		"S_MST_NB"),

  /* UPC put/get syncs */
  EnumToStr_t(INTRN_WAIT_SYNC_MEM,	"SYNC_MEM"),
  EnumToStr_t(INTRN_WAIT_SYNC_REG,	"SYNC_REG"),
  EnumToStr_t(INTRN_WAIT_SYNC_FLOAT,	"SYNC_FLOAT"),
  EnumToStr_t(INTRN_WAIT_SYNC_DOUBLE,	"SYNC_DOUBLE"),		
  /* UPC pointer arithmetic */
  EnumToStr_t(INTRN_SPTRADD,		"S_PTRADD"),
  EnumToStr_t(INTRN_SPTRDIFF,		"S_PTRDIFF"),
  EnumToStr_t(INTRN_SCVTADDR,		"S_CVTADDR"),
 
  /* UPC sync */
  EnumToStr_t(INTRN_UPCBAR,		"UPC_BARRIER"),
  EnumToStr_t(INTRN_UPCWAIT,		"UPC_WAIT"),
  EnumToStr_t(INTRN_UPCNTFY,		"UPC_NOTIFY"),
  EnumToStr_t(INTRN_UPCIAFFT,		"UPC_INT_AFFT"),

  EnumToStr_t(INTRN_EXIT,		"UPC_EXIT"),
  EnumToStr_t(INTRN_MYTHREAD,		"MYTHREAD"),
  EnumToStr_t(INTRN_THREADS,		"THREADS"),
  EnumToStr_t(INTRN_ALL_ALLOC,		"ALL_ALLOC"),
  EnumToStr_t(INTRN_GLOBAL_ALLOC,	"GLOBAL_ALLOC"),
  EnumToStr_t(INTRN_LOCAL_ALLOC,	"LOCAL_ALLOC"),
  EnumToStr_t(INTRN_FREE,		"UPC_FREE"),
  EnumToStr_t(INTRN_THREADOF_S,		"THREADOF_S"),
  EnumToStr_t(INTRN_THREADOF_P,		"THREADOF_P"),
  EnumToStr_t(INTRN_PHASEOF_S,		"PHASEOF_S"),
  EnumToStr_t(INTRN_PHASEOF_P,		"PHASEOF_P"),
  EnumToStr_t(INTRN_ADDROF_S,		"ADDROF_S"),
  EnumToStr_t(INTRN_ADDROF_P,		"ADDROF_P"),
  EnumToStr_t(INTRN_G_LOCK_ALLOC,	"G_LOCK_ALLOC"),
  EnumToStr_t(INTRN_A_LOCK_ALLOC,	"A_LOCK_ALLOC"),
  EnumToStr_t(INTRN_LOCK_FREE,		"LOCK_FREE"),
  EnumToStr_t(INTRN_LOCK,		"UPC_LOCK"),
  EnumToStr_t(INTRN_LOCK_ATTEMPT,	"LOCK_ATTEMPT"),
  EnumToStr_t(INTRN_LOCK_UNLOCK,	"UPC_UNLOCK"),
  EnumToStr_t(INTRN_UPC_MEMCPY,		"UPC_MEMCPY"),
  EnumToStr_t(INTRN_UPC_MEMGET,		"UPC_MEMGET"),
  EnumToStr_t(INTRN_UPC_MEMPUT,		"UPC_MEMPUT"),
  EnumToStr_t(INTRN_UPC_MEMSET,		"UPC_MEMSET"),
  EnumToStr_t(INTRN_S_TO_L, "S_TO_L"),
  EnumToStr_t(INTRN_P_TO_L, "P_TO_L"),
  EnumToStr_t(INTRN_S_RESET, "S_RESET"),
  EnumToStr_t(INTRN_S_RESET_REF, "S_RESET_REF"),
  EnumToStr_t(INTRN_ISNULL_S, "ISNULL_S"),
  EnumToStr_t(INTRN_ISNULL_P, "ISNULL_P"),
  EnumToStr_t(INTRN_ADD_S, "ADD_S"),
  EnumToStr_t(INTRN_INC_S, "INC_S"),
  EnumToStr_t(INTRN_ADD_P1, "ADD_P1"),
  EnumToStr_t(INTRN_INC_P1, "INC_P1"),
  EnumToStr_t(INTRN_EQ_S_S, "EQ_S_S"),
  EnumToStr_t(INTRN_EQ_S_P, "EQ_S_P"),
  EnumToStr_t(INTRN_EQ_P_P, "EQ_P_P"),
  EnumToStr_t(INTRN_SUB_S,  "SUB_S"),
  EnumToStr_t(INTRN_SUB_P1, "SUB_P1"),
  EnumToStr_t(INTRN_AFF_S,  "AFF_S"),
  EnumToStr_t(INTRN_AFF_P, "AFF_P"),
  EnumToStr_t(INTRN_PUT_S, "PUT_S"),
  EnumToStr_t(INTRN_PUT_P, "PUT_P"),
  EnumToStr_t(INTRN_GET_S, "GET_S"),
  EnumToStr_t(INTRN_GET_P, "GET_P"),
  EnumToStr_t(INTRN_PUT_NB_S, "PUT_NB_S"),
  EnumToStr_t(INTRN_GET_NB_S, "GET_NB_S"),
  EnumToStr_t(INTRN_PUT_NB_P, "PUT_NB_P"),
  EnumToStr_t(INTRN_GET_NB_P, "GET_NB_P"),
  EnumToStr_t(INTRN_WAIT_SYN, "WAIT_SYN"),
  EnumToStr_t(INTRN_TRY_SYN, "TRY_SYN"),
  EnumToStr_t(INTRN_PUT_NBI_S, "PUT_NBI_S"),
  EnumToStr_t(INTRN_GET_NBI_S, "GET_NBI_S"),
  EnumToStr_t(INTRN_PUT_NBI_P, "PUT_NBI_P"),
  EnumToStr_t(INTRN_GET_NBI_P, "GET_NBI_P"),
  EnumToStr_t(INTRN_WAIT_SYN_GET, "WAIT_SYN_GET"),
  EnumToStr_t(INTRN_WAIT_SYN_PUT, "WAIT_SYN_PUT"),
  EnumToStr_t(INTRN_WAIT_SYN_ALL, "WAIT_SYN_ALL"),
  EnumToStr_t(INTRN_TRY_SYN_GET, "TRY_SYN_GET"),
  EnumToStr_t(INTRN_TRY_SYN_PUT, "TRY_SYN_PUT"),
  EnumToStr_t(INTRN_TRY_SYN_ALL, "TRY_SYN_ALL"),
  EnumToStr_t(INTRN_BEGIN_REGION, "BEGIN_REGION"),
  EnumToStr_t(INTRN_END_REGION, "END_REGION"),
  EnumToStr_t(INTRN_PUT_S_VAL, "PUT_S_VAL"),
  EnumToStr_t(INTRN_PUT_NB_S_VAL, "PUT_NB_S_VAL"),
  EnumToStr_t(INTRN_PUT_NBI_S_VAL, "PUT_NBI_S_VAL"),
  EnumToStr_t(INTRN_PUT_P_VAL, "PUT_P_VAL"),
  EnumToStr_t(INTRN_PUT_NB_P_VAL, "PUT_NB_P_VAL"),
  EnumToStr_t(INTRN_PUT_NBI_P_VAL, "PUT_NBI_P_VAL"),
  EnumToStr_t(INTRN_GET_S_VAL, "GET_S_VAL"),
  EnumToStr_t(INTRN_GET_P_VAL, "GET_P_VAL"),
  EnumToStr_t(INTRN_GET_NB_S_VAL,"GET_NB_S_VAL"),
  EnumToStr_t(INTRN_GET_NB_P_VAL, "GET_NB_P_VAL"),
  EnumToStr_t(INTRN_PUT_S_FVAL, "PUT_S_FVAL"), 
  EnumToStr_t(INTRN_PUT_S_DVAL, "PUT_S_DVAL"),
  EnumToStr_t(INTRN_GET_S_FVAL, "GET_S_FVAL"),
  EnumToStr_t(INTRN_GET_S_DVAL, "GET_S_DVAL"),
  EnumToStr_t(INTRN_PUT_P_FVAL, "PUT_P_FVAL"),
  EnumToStr_t(INTRN_PUT_P_DVAL, "PUT_P_DVAL"),
  EnumToStr_t(INTRN_GET_P_FVAL, "GET_P_FVAL"),
  EnumToStr_t(INTRN_GET_P_DVAL, "GET_P_DVAL"),
  EnumToStr_t(INTRN_WAIT_SYN_VAL, "WAIT_SYN_VAL"),
  EnumToStr_t(INTRN_TLD_ADDR, "TLD_ADDR"),
  EnumToStr_t(INTRN_ADD_PI, "ADD_PI"),
  EnumToStr_t(INTRN_INC_PI, "INC_PI"),
  EnumToStr_t(INTRN_UPCFENCE, "UPCFENCE"),
  EnumToStr_t(INTRN_S_TO_P, "S_TO_P"),
  EnumToStr_t(INTRN_P_TO_S, "P_TO_S"),
  EnumToStr_t(INTRN_SETNULL_S, "SETNULL_S"),
  EnumToStr_t(INTRN_SETNULL_P, "SETNULL_P"),
  EnumToStr_t(INTRN_SETNULL_S_R, "SETNULL_S_R"),
  EnumToStr_t(INTRN_SETNULL_P_R, "SETNULL_P_R"),
  EnumToStr_t(INTRN_SUB_PI, "SUB_PI"),
  EnumToStr_t(INTRN_U4READFRAMEPOINTER,	"U4READFRAMEPOINTER"),
  EnumToStr_t(INTRN_U8READFRAMEPOINTER,	"U8READFRAMEPOINTER"),
  EnumToStr_t(INTRN_APPLY_ARGS,		"APPLY_ARGS"),
  EnumToStr_t(INTRN_APPLY,		"APPLY"),
  EnumToStr_t(INTRN_RETURN,		"RETURN"),
  EnumToStr_t(INTRN_VA_START,		"VA_START"),
  EnumToStr_t(INTRN_SAVE_XMMS,		"SAVE_XMMS"),
  EnumToStr_t(INTRN_LANDING_PAD_ENTRY,	"INTRN_LANDING_PAD_ENTRY"),
  EnumToStr_t(INTRN_ISGREATER,		"ISGREATER"),
  EnumToStr_t(INTRN_ISGREATEREQUAL,	"ISGREATEREQUAL"),
  EnumToStr_t(INTRN_ISLESS,		"ISLESS"),
  EnumToStr_t(INTRN_ISLESSEQUAL,	"ISLESSEQUAL"),
  EnumToStr_t(INTRN_ISLESSGREATER,	"ISLESSGREATER"),
  EnumToStr_t(INTRN_ISUNORDERED,	"INTRN_ISUNORDERED"),

  EnumToStr_t(INTRN_SUBSU2,		"INTRN_SUBSU2"),
  EnumToStr_t(INTRN_SUBSV16I2,		"INTRN_SUBSV16I2"),
};


EnumToStr_t IostatementToNameTbl [] = {
  EnumToStr_t((IOSTATEMENT)0,		"IOSTATEMENT_0"),
  EnumToStr_t(IOS_BACKSPACE,		"BACKSPACE"),
  EnumToStr_t(IOS_CLOSE,		"CLOSE"),
  EnumToStr_t(IOS_DEFINEFILE,		"DEFINEFILE"),
  EnumToStr_t(IOS_DELETE,		"DELETE"),
  EnumToStr_t(IOS_ENDFILE,		"ENDFILE"),
  EnumToStr_t(IOS_FIND,			"FIND"),
  EnumToStr_t(IOS_INQUIRE,		"INQUIRE"),
  EnumToStr_t(IOS_NAMELIST,		"NAMELIST"),
  EnumToStr_t(IOS_OPEN,			"OPEN"),
  EnumToStr_t(IOS_REWIND,		"REWIND"),
  EnumToStr_t(IOS_UNLOCK,		"UNLOCK"),
  EnumToStr_t(IOS_ACCEPT,		"ACCEPT"),
  EnumToStr_t(IOS_DECODE,		"DECODE"),
  EnumToStr_t(IOS_ENCODE,		"ENCODE"),
  EnumToStr_t(IOS_PRINT,		"PRINT"),
  EnumToStr_t(IOS_READ,			"READ"),
  EnumToStr_t(IOS_REWRITE,		"REWRITE"),
  EnumToStr_t(IOS_TYPE,			"TYPE"),
  EnumToStr_t(IOS_WRITE,		"WRITE"),
  EnumToStr_t(IOS_CR_FWU,		"UNFORMATTED_WRITE"),
  EnumToStr_t(IOS_CR_FRU,		"UNFORMATTED_READ"),
  EnumToStr_t(IOS_CR_FWF,		"FORMATTED_WRITE"),
  EnumToStr_t(IOS_CR_FRF,		"FORMATTED_READ"),
  EnumToStr_t(IOS_CR_FWN,		"NAMELIST_WRITE"),
  EnumToStr_t(IOS_CR_FRN,		"NAMELIST_READ"),
  EnumToStr_t(IOS_INQLENGTH,		"INQUIRE_LENGTH"),
  EnumToStr_t(IOS_CR_OPEN,		"OPEN"),
  EnumToStr_t(IOS_CR_CLOSE,		"CLOSE"),
  EnumToStr_t(IOS_CR_ENDFILE,		"ENDFILE"),
  EnumToStr_t(IOS_CR_REWIND,		"REWIND"),
  EnumToStr_t(IOS_CR_INQUIRE,		"INQUIRE"),
  EnumToStr_t(IOS_CR_BACKSPACE,		"BACKSPACE"),
  EnumToStr_t(IOS_CR_BUFFERIN,		"BUFFERIN"),
  EnumToStr_t(IOS_CR_BUFFEROUT,		"BUFFEROUT")
};


EnumToStr_t IoitemToNameTbl [] = {
  EnumToStr_t((IOITEM)0,		"IOITEM_0"),
  EnumToStr_t(IOU_NONE,			"NONE"),
  EnumToStr_t(IOU_DEFAULT,		"DEFAULT"),
  EnumToStr_t(IOU_EXTERNAL,		"EXTERNAL"),
  EnumToStr_t(IOU_INTERNAL,		"INTERNAL"),
  EnumToStr_t(IOU_DOPE,			"DOPE"),
  EnumToStr_t((IOITEM)6,		"IOITEM_6"),	/* spare */
  EnumToStr_t((IOITEM)7,		"IOITEM_7"),	/* spare */
  EnumToStr_t((IOITEM)8,		"IOITEM_8"),	/* spare */
  EnumToStr_t((IOITEM)9,		"IOITEM_9"),	/* spare */
  EnumToStr_t(IOF_NONE,			"NONE"),
  EnumToStr_t(IOF_ASSIGNED_VAR,		"ASSIGNED_VAR"),
  EnumToStr_t(IOF_CHAR_EXPR,		"CHAR_EXPR"),
  EnumToStr_t(IOF_LABEL,		"LABEL"),
  EnumToStr_t(IOF_LIST_DIRECTED,	"LIST_DIRECTED"),
  EnumToStr_t(IOF_NAMELIST_DIRECTED,	"NAMELIST_DIRECTED"),
  EnumToStr_t(IOF_UNFORMATTED,		"UNFORMATTED"),
  EnumToStr_t(IOF_CR_PARSFMT,		"PREPARSED_FORMAT"),
  EnumToStr_t(IOF_CR_FMTSRC,		"FORMAT_SOURCE"),
  EnumToStr_t(IOF_CR_FMTSRC_DOPE,	"FORMAT_SOURCE_DOPE"),
  EnumToStr_t((IOITEM)20,		"IOITEM_20"),	/* spare */
  EnumToStr_t((IOITEM)21,		"IOITEM_21"),	/* spare */
  EnumToStr_t((IOITEM)22,		"IOITEM_22"),	/* spare */
  EnumToStr_t((IOITEM)23,		"IOITEM_23"),	/* spare */
  EnumToStr_t((IOITEM)24,		"IOITEM_24"),	/* spare */
  EnumToStr_t(IOC_ACCESS,		"ACCESS"),
  EnumToStr_t(IOC_ASSOCIATEVARIABLE,	"ASSOCIATEVARIABLE"),
  EnumToStr_t(IOC_BLANK,		"BLANK"),
  EnumToStr_t(IOC_CARRIAGECONTROL,	"CARRIAGECONTROL"),
  EnumToStr_t(IOC_DEFAULTFILE,		"DEFAULTFILE"),
  EnumToStr_t(IOC_DIRECT,		"DIRECT"),
  EnumToStr_t(IOC_DISPOSE,		"DISPOSE"),
  EnumToStr_t(IOC_END,			"END"),
  EnumToStr_t(IOC_ERR,			"ERR"),
  EnumToStr_t(IOC_EXIST,		"EXIST"),
  EnumToStr_t(IOC_FILE,			"FILE"),
  EnumToStr_t(IOC_FORM,			"FORM"),
  EnumToStr_t(IOC_FORMATTED,		"FORMATTED"),
  EnumToStr_t(IOC_IOSTAT,		"IOSTAT"),
  EnumToStr_t(IOC_KEY,			"KEY"),
  EnumToStr_t(IOC_KEYEQ,		"KEYEQ"),
  EnumToStr_t(IOC_KEYGE,		"KEYGE"),
  EnumToStr_t(IOC_KEYGT,		"KEYGT"),
  EnumToStr_t(IOC_KEY_START,		"KEY_START"),
  EnumToStr_t(IOC_KEY_END,		"KEY_END"),
  EnumToStr_t(IOC_KEY_CHARACTER,	"KEY_CHARACTER"),
  EnumToStr_t(IOC_KEY_INTEGER,		"KEY_INTEGER"),
  EnumToStr_t(IOC_KEYED,		"KEYED"),
  EnumToStr_t(IOC_KEYID,		"KEYID"),
  EnumToStr_t(IOC_MAXREC,		"MAXREC"),
  EnumToStr_t(IOC_NAME,			"NAME"),
  EnumToStr_t(IOC_NAMED,		"NAMED"),
  EnumToStr_t(IOC_NEXTREC,		"NEXTREC"),
  EnumToStr_t(IOC_NML,			"NML"),
  EnumToStr_t(IOC_NUMBER,		"NUMBER"),
  EnumToStr_t(IOC_OPENED,		"OPENED"),
  EnumToStr_t(IOC_ORGANIZATION,		"ORGANIZATION"),
  EnumToStr_t(IOC_READONLY,		"READONLY"),
  EnumToStr_t(IOC_REC,			"REC"),
  EnumToStr_t(IOC_RECCOUNT,		"RECCOUNT"),
  EnumToStr_t(IOC_RECL,			"RECL"),
  EnumToStr_t(IOC_RECORDTYPE,		"RECORDTYPE"),
  EnumToStr_t(IOC_SEQUENTIAL,		"SEQUENTIAL"),
  EnumToStr_t(IOC_SHARED,		"SHARED"),
  EnumToStr_t(IOC_STATUS,		"STATUS"),
  EnumToStr_t(IOC_TYPE,			"TYPE"),
  EnumToStr_t(IOC_U,			"U"),
  EnumToStr_t(IOC_UNFORMATTED,		"UNFORMATTED"),
  EnumToStr_t(IOC_VARFMT,		"VARFMT"),
  EnumToStr_t(IOC_VARFMT_ORIGFMT,	"VARFMT_ORIGFMT"),
  EnumToStr_t(IOC_CR_EEEFLAG,		"END_EOR_EOF_FLAG"),
  EnumToStr_t(IOC_ADVANCE,		"ADVANCE"),
  EnumToStr_t(IOC_SIZE,			"SIZE"),
  EnumToStr_t(IOC_CR_FLFLAG,		"FIRST_LAST_FLAG"),
  EnumToStr_t(IOC_EOR,			"EOR"),
  EnumToStr_t(IOC_INQLENGTH_VAR,	"INQLENGTH_VAR"),
  EnumToStr_t(IOC_CR_EDFLAG,		"ENCODE_DECODE_FLAG"),
  EnumToStr_t(IOC_PAD,			"PAD"),
  EnumToStr_t(IOC_DELIM,		"DELIM"),
  EnumToStr_t(IOC_ACTION,		"ACTION"),
  EnumToStr_t(IOC_POSITION,		"POSITION"),
  EnumToStr_t(IOC_READWRITE,		"READWRITE"),
  EnumToStr_t(IOC_WRITE,		"WRITE"),
  EnumToStr_t(IOC_READ,			"READ"),
  EnumToStr_t(IOC_ERRFLAG,		"ERRFLAG"),
  EnumToStr_t((IOITEM)85,		"IOITEM_85"),	/* spare */
  EnumToStr_t((IOITEM)86,		"IOITEM_86"),	/* spare */
  EnumToStr_t((IOITEM)87,		"IOITEM_87"),	/* spare */
  EnumToStr_t((IOITEM)88,		"IOITEM_88"),	/* spare */
  EnumToStr_t((IOITEM)89,		"IOITEM_89"),	/* spare */
  EnumToStr_t((IOITEM)90,		"IOITEM_90"),	/* spare */
  EnumToStr_t((IOITEM)91,		"IOITEM_91"),	/* spare */
  EnumToStr_t((IOITEM)92,		"IOITEM_92"),	/* spare */
  EnumToStr_t((IOITEM)93,		"IOITEM_93"),	/* spare */
  EnumToStr_t((IOITEM)94,		"IOITEM_94"),	/* spare */
  EnumToStr_t(IOL_ARRAY,		"ARRAY"),
  EnumToStr_t(IOL_CHAR,			"CHAR"),
  EnumToStr_t(IOL_CHAR_ARRAY,		"CHAR_ARRAY"),
  EnumToStr_t(IOL_EXPR,			"EXPR"),
  EnumToStr_t(IOL_IMPLIED_DO,		"IMPLIED_DO"),
  EnumToStr_t(IOL_IMPLIED_DO_1TRIP,	"IMPLIED_DO_1TRIP"),
  EnumToStr_t(IOL_LOGICAL,		"LOGICAL"),
  EnumToStr_t(IOL_RECORD,		"RECORD"),
  EnumToStr_t(IOL_VAR,			"VAR"),
  EnumToStr_t(IOL_DOPE,			"DOPE"),
  EnumToStr_t((IOITEM) 105,		"IOITEM_105"),	/* spare */
  EnumToStr_t((IOITEM) 106,		"IOITEM_106"),	/* spare */
  EnumToStr_t((IOITEM) 107,		"IOITEM_107"),	/* spare */
  EnumToStr_t((IOITEM) 108,		"IOITEM_108"),	/* spare */
  EnumToStr_t((IOITEM) 109,		"IOITEM_109"),	/* spare */
  EnumToStr_t((IOITEM) 110,		"IOITEM_110"),	/* spare */
  EnumToStr_t((IOITEM) 111,		"IOITEM_111"),	/* spare */
  EnumToStr_t((IOITEM) 112,		"IOITEM_112"),	/* spare */
  EnumToStr_t((IOITEM) 113,		"IOITEM_113"),	/* spare */
  EnumToStr_t((IOITEM) 114,		"IOITEM_114"),	/* spare */
};


//----------------------------------------------------------------------
// 
//----------------------------------------------------------------------


const char *
get_intrinsic_name ( INTRINSIC opcode )
{
  using namespace ir_a2b;
  return MapEnumToStr<EnumToStr_t, IntrinsicToNameTbl, 
                      INTRINSIC_LAST+1>("IntrinsicToNameTbl", (INT)opcode);
}


INTRINSIC
get_intrinsic_from_name( const char* name )
{
  using namespace ir_a2b;
  return (INTRINSIC)MapStrToEnum<EnumToStr_t, IntrinsicToNameTbl, 
                                 INTRINSIC_LAST+1>("IntrinsicToNameTbl", name);
}


const char *
get_iostatement_name ( IOSTATEMENT opcode )
{
  using namespace ir_a2b;
  return MapEnumToStr<EnumToStr_t, IostatementToNameTbl, 
		      IOSTATEMENT_LAST+1>("IostatementToNameTbl", (INT)opcode);
}


IOSTATEMENT
get_iostatement_from_name(const char* name)
{
  using namespace ir_a2b;
  return (IOSTATEMENT)MapStrToEnum<EnumToStr_t, IostatementToNameTbl, 
                                  IOSTATEMENT_LAST+1>("IostatementToNameTbl",
						      name);
}


const char *
get_ioitem_name ( IOITEM opcode )
{
  using namespace ir_a2b;
  return MapEnumToStr<EnumToStr_t, IoitemToNameTbl, 
		      IOITEM_LAST+1>("IoitemToNameTbl", (INT)opcode);
}


IOITEM
get_ioitem_from_name(const char* name)
{
  using namespace ir_a2b;
  return (IOITEM)MapStrToEnum<EnumToStr_t, IoitemToNameTbl, 
                              IOITEM_LAST+1>("IoitemToNameTbl", name);
}


const char *
get_iolibrary_name( IOLIB lib)
{
  switch (lib) {
   case IOLIB_UNSPECIFIED:
     return ("unspec");
   case IOLIB_MIPS:
     return ("mips");
   case IOLIB_CRAY:
     return ("cray");
   default:
     return ("unknown");
  }
}
